#include "rapidjson_util.h"
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/stringbuffer.h"


#define CONSTRUCT_MODE_ONE (0) // 构造模式1

#if 0
// 获取有格式的json字符串
static std::string getFormatJsonString(const rapidjson::Document& document)
{
    rapidjson::StringBuffer buffer;
    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer); // 有格式输出
    document.Accept(writer);
    return buffer.GetString();
}
#endif

// 获取无格式的json字符串
static std::string getUnformatJsonString(const rapidjson::Document& document)
{
    rapidjson::StringBuffer buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); // 无格式输出
    document.Accept(writer);
    return buffer.GetString();
}

// 获取无格式的json字符串
static std::string getUnformatJsonString(const rapidjson::Value& value)
{
    rapidjson::StringBuffer strBuffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(strBuffer); // 无格式输出
    value.Accept(writer);
    return strBuffer.GetString();
}

// 清理缓存
static void clearAllInfos(rapidjson::Value& value)
{
    if (value.IsObject()) {
        value.RemoveAllMembers();
    } else if (value.IsArray()) {
        value.Clear();
    }
    return;
}

// 清理缓存
static void clearAllInfos(rapidjson::Document& documet)
{
    if (documet.IsObject()) {
        documet.RemoveAllMembers();
    } else if (documet.IsArray()) {
        documet.Clear();
    }
    return;
}


/************************************************
 * 功能：封装一层级的Json数据信息，每层级有object和array时，也调用该接口进一步封装
 * 输入参数：
 *      vtJsonInfos：待封装的数据集合
 * 返回值：
 *      std::string：封装的json数据信息
 * ***********************************************/
std::string packageAllJsonInfoByRapid(const std::vector<RapidJsonInfo>& vtJsonInfos)
{
    rapidjson::Document document;
    document.SetObject();
    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();

    // 拼组数据
    for (size_t i = 0, size = vtJsonInfos.size(); i < size; ++i) {
        const RapidJsonInfo& jsonInfo = vtJsonInfos[i];
        if (RapidJsonDataType::RPJDT_INT32 == jsonInfo.emDataType) {
            rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
            rapidjson::Value value(jsonInfo.iVal);
            document.AddMember(key, value, allocator);
        } else if (RapidJsonDataType::RPJDT_UINT32 == jsonInfo.emDataType) {
            rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
            rapidjson::Value value(jsonInfo.uiVal);
            document.AddMember(key, value, allocator);
        } else if (RapidJsonDataType::RPJDT_DOUBLE == jsonInfo.emDataType) {
            rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
            rapidjson::Value value(jsonInfo.dVal);
            document.AddMember(key, value, allocator);
        } else if (RapidJsonDataType::RPJDT_BOOL == jsonInfo.emDataType) {
            rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
            rapidjson::Value value(jsonInfo.bVal);
            document.AddMember(key, value, allocator);
        } else if (RapidJsonDataType::RPJDT_STRING == jsonInfo.emDataType) {
            rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
            rapidjson::Value value(jsonInfo.strVal.c_str(), allocator);
            document.AddMember(key, value, allocator);
        } else if (RapidJsonDataType::RPJDT_OBJ == jsonInfo.emDataType
                   || RapidJsonDataType::RPJDT_ARR == jsonInfo.emDataType) {
            rapidjson::Document doc;
            doc.Parse(jsonInfo.strVal.c_str());
            if (!doc.HasParseError()) {
                // 深拷贝
                rapidjson::Value key(jsonInfo.strKey.c_str(), allocator);
                rapidjson::Value value;
                value.CopyFrom(doc, allocator);
                document.AddMember(key, value, allocator);
            }
        } else {
            // TODO
        }
    }

    return getUnformatJsonString(document);
}

/************************************************
 * 功能：解析一层级的Json数据信息，该层级有object和array时，再调用该接口进一步解析
 * 输入参数：
 *      strJson：待解析的json数据
 * 输出参数：
 *      vtJsonInfos：解析数据集合
 * 返回值：
 *      bool：执行结果，true -- 成功，false -- 失败
 * ***********************************************/
bool parseAllJsonInfoByRapid(const std::string& strJson
                             , std::vector<RapidJsonInfo>& vtJsonInfos)
{
    rapidjson::Document document;
    //rapidjson::Document::AllocatorType& allocator = document.GetAllocator();
    document.Parse(strJson.c_str());
    if (document.HasParseError()) {
        return false;
    }

    //rapidjson::Value::ConstMemberIterator iter = document.MemberBegin();
    for (auto iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter) {
        const rapidjson::Value& key = iter->name;
        const rapidjson::Value& value = iter->value;

        if (key.IsString()) {
            RapidJsonInfo jsonInfo;
            jsonInfo.strKey = key.GetString();

            if (value.IsString()) {
                jsonInfo.emDataType = RapidJsonDataType::RPJDT_STRING;
                jsonInfo.strVal = value.GetString();
                vtJsonInfos.emplace_back(jsonInfo);
            } else if (value.IsInt()) {
                jsonInfo.emDataType = RapidJsonDataType::RPJDT_INT32;
                jsonInfo.iVal = value.GetInt();
                vtJsonInfos.emplace_back(jsonInfo);
            } else if (value.IsUint()) {
                jsonInfo.emDataType = RapidJsonDataType::RPJDT_UINT32;
                jsonInfo.uiVal = value.GetUint();
                vtJsonInfos.emplace_back(jsonInfo);
            } else if (value.IsDouble()) {
                jsonInfo.emDataType = RapidJsonDataType::RPJDT_DOUBLE;
                jsonInfo.dVal = value.GetDouble();
                vtJsonInfos.emplace_back(jsonInfo);
            } else if (value.IsBool()) {
                jsonInfo.emDataType = RapidJsonDataType::RPJDT_BOOL;
                jsonInfo.bVal = value.GetBool();
                vtJsonInfos.emplace_back(jsonInfo);
            } else if (value.IsArray() || value.IsObject()) {
                jsonInfo.emDataType = value.IsArray() ? RapidJsonDataType::RPJDT_ARR : RapidJsonDataType::RPJDT_OBJ;
                jsonInfo.strVal = getUnformatJsonString(value);
                vtJsonInfos.emplace_back(jsonInfo);
            } else {
                // TODO
            }
        } else {
            // TODO
        }
    }

    return true;
}


class RapidJsonUtil::Impl
{
public:
    rapidjson::Document document; // rapidjson的文本解析对象
    //rapidjson::Value value; // rapidjson的数值解析对象
};

/************************************************
 * 功能：构造函数
 * 输入参数：
 *      eType：Data -- 普通类型，Array -- JSON数组类型
 * ***********************************************/
RapidJsonUtil::RapidJsonUtil(Type eType)
{
    m_spImplInstance = std::make_shared<RapidJsonUtil::Impl>();
    if (Array == eType) {
        m_spImplInstance->document.SetArray();
        //m_spImplInstance->value.SetArray();
    } else {
        m_spImplInstance->document.SetObject();
        //m_spImplInstance->value.SetObject();
    }
}

/************************************************
 * 功能：构造函数
 * 输入参数：
 *      strJsonData：JSON数据
 * ***********************************************/
RapidJsonUtil::RapidJsonUtil(const std::string &strJsonData)
{
    m_spImplInstance = std::make_shared<RapidJsonUtil::Impl>();
    if (m_spImplInstance) {
        m_spImplInstance->document.Parse(strJsonData.data());
        if (m_spImplInstance->document.HasParseError()) {
            m_bOk = false;
            m_spImplInstance->document.SetObject(); // 设置为空对象以避免错误
            //m_spImplInstance->value.SetObject(); // 设置为空对象以避免错误
        } else {
            // 深拷贝
            //m_spImplInstance->value.CopyFrom(m_spImplInstance->document, m_spImplInstance->document.GetAllocator());
        }
    }
}

/************************************************
 * 功能：拷贝构造函数
 * 输入参数：
 *      objOther：JSON对象
 * ***********************************************/
RapidJsonUtil::RapidJsonUtil(const RapidJsonUtil &objOther)
{
    // rapidjson要执行深拷贝
    m_spImplInstance = std::make_shared<RapidJsonUtil::Impl>();
    if (m_spImplInstance) {
        if (objOther.m_spImplInstance) {
            // 深拷贝
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            m_spImplInstance->document.CopyFrom(objOther.m_spImplInstance->document, allocator);
            //m_spImplInstance->value.CopyFrom(objOther.m_spImplInstance->value, allocator);
        } else {
            m_spImplInstance->document.SetObject();
            //m_spImplInstance->value.SetObject();
        }
    }

    m_bOk = objOther.m_bOk;
}

/************************************************
 * 功能：赋值构造函数
 * 输入参数：
 *      objOther：JSON对象
 * 返回值：
 *      RapidJsonUtil：新的JSON对象
 * ***********************************************/
RapidJsonUtil& RapidJsonUtil::operator=(const RapidJsonUtil &objOther)
{
    if(this == &objOther) {
        return *this;
    }

    if (m_spImplInstance) {
        clearAllInfos(m_spImplInstance->document);
        m_spImplInstance.reset();
        m_spImplInstance = nullptr;
    }

    // rapidjson要执行深拷贝
    m_spImplInstance = std::make_shared<RapidJsonUtil::Impl>();
    if (m_spImplInstance) {
        if (objOther.m_spImplInstance) {
            // 深拷贝
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            m_spImplInstance->document.CopyFrom(objOther.m_spImplInstance->document, allocator);
            //m_spImplInstance->value.CopyFrom(objOther.m_spImplInstance->value, allocator);
        } else {
            m_spImplInstance->document.SetObject();
            //m_spImplInstance->value.SetObject();
        }
    }

    m_bOk = objOther.m_bOk;

    return *this;
}

/************************************************
 * 功能：析构函数
 * ***********************************************/
RapidJsonUtil::~RapidJsonUtil()
{
    if (m_spImplInstance) {
        clearAllInfos(m_spImplInstance->document);
        m_spImplInstance.reset();
        m_spImplInstance = nullptr;
    }
}

/************************************************
 * 功能：解析json是否正常
 * 返回值：
 *      bool：解析结果，true -- 正常，false -- 异常
 * ***********************************************/
bool RapidJsonUtil::isJsonOk() const
{
    return m_bOk;
}

/************************************************
 * 功能：读取JSON数据
 * 返回值：
 *      std::string：JSON数据
 * ***********************************************/
std::string RapidJsonUtil::data()
{
    std::string strJson = "";
#if 1
    if (m_spImplInstance) {
        rapidjson::StringBuffer buffer;
        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer); // 有格式输出
        m_spImplInstance->document.Accept(writer);
        strJson = buffer.GetString();
    }
#else
    if (m_spImplInstance) {
        strJson = getFormatJsonString(m_spImplInstance->document);
    }
#endif
    return strJson;
}

/************************************************
 * 功能：读取对应无格式的JSON数据
 * 返回值：
 *      std::string：无格式JSON数据
 * ***********************************************/
std::string RapidJsonUtil::unformattedData()
{
    std::string strJson = "";
    if (m_spImplInstance) {
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); // 无格式输出
        m_spImplInstance->document.Accept(writer);
        strJson = buffer.GetString();
    }

    return strJson;
}

/************************************************
 * 功能：读取子JSON对象
 * 输入参数：
 *      strKey：键值
 * 返回值：
 *      RapidJsonUtil：对应的子对象
 * ***********************************************/
RapidJsonUtil RapidJsonUtil::value(const std::string &strKey)
{
    RapidJsonUtil objUtil;
    objUtil.m_bOk = false;

    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            if (objUtil.m_spImplInstance) {
                objUtil.m_bOk = true;
                // 深拷贝
                rapidjson::Document::AllocatorType& allocator = objUtil.m_spImplInstance->document.GetAllocator();
                objUtil.m_spImplInstance->document.CopyFrom(m_spImplInstance->document[strKey.c_str()], allocator);
            }
        }
    }

    return objUtil;
}

/************************************************
 * 功能：返回JSON数组子对象个数
 * 返回值：
 *      int：JSON数组子对象个数
 * ***********************************************/
int RapidJsonUtil::count() const
{
    int iRet = 0;
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            iRet = static_cast<int>(m_spImplInstance->document.Size());
        } else {
            iRet = static_cast<int>(m_spImplInstance->document.MemberCount());
        }
    }
    return iRet;
}

/************************************************
 * 功能：读取JSON数组子对象
 * 输入参数：
 *      iIndex：JSON数组子对象索引
 * 返回值：
 *      RapidJsonUtil：JSON数组子对象
 * ***********************************************/
RapidJsonUtil RapidJsonUtil::at(int iIndex) const
{
    RapidJsonUtil objUtil;
    objUtil.m_bOk = false;

    if (m_spImplInstance && m_spImplInstance->document.IsArray()) {
        int iSize = static_cast<int>(m_spImplInstance->document.Size());
        if (-1 < iIndex && iIndex < iSize) {
            objUtil.m_spImplInstance = std::make_shared<RapidJsonUtil::Impl>();
            if (objUtil.m_spImplInstance) {
                objUtil.m_bOk = true;
                // 深拷贝
                rapidjson::Document::AllocatorType& allocator = objUtil.m_spImplInstance->document.GetAllocator();
                objUtil.m_spImplInstance->document.CopyFrom(m_spImplInstance->document[iIndex], allocator);
            }
        }
    }

    return objUtil;
}

/************************************************
 * 功能：判断是否是JSON数组类型
 * 返回值：
 *      bool：是否JOSN数组，true -- 是，false -- 否
 * ***********************************************/
bool RapidJsonUtil::isArray() const
{
    bool bRet = false;
    if (m_spImplInstance) {
        bRet = m_spImplInstance->document.IsArray();
    }
    return bRet;
}

/************************************************
 * 功能：JSON对象是否存在
 * 输入参数：
 *      strKey：键值
 * 返回值：
 *      bool：是否存在，true -- 存在，false -- 不存在
 * ***********************************************/
bool RapidJsonUtil::isExist(const std::string &strKey)
{
    bool bRet = false;
    if (m_spImplInstance) {
        bRet = m_spImplInstance->document.HasMember(strKey.c_str());
    }
    return bRet;
}

/************************************************
 * 功能：添加空数据
 * 输入参数：
 *      strKey：键值
 * ***********************************************/
void RapidJsonUtil::addNull(const std::string &strKey)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //setNull(strKey);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetNull();
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kNullType);
            value.SetNull();
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kNullType);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置空数据
 * 输入参数：
 *      strKey：键值
 * ***********************************************/
void RapidJsonUtil::setNull(const std::string &strKey)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetNull();
        }
    }

    return;
}

/************************************************
 * 功能：添加string型键值数据
 * 输入参数：
 *      strKey：键值
 *      pValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const char* pValue)
{
    if (pValue) {
        if (m_spImplInstance) {
            if (m_spImplInstance->document.HasMember(strKey.c_str())) {
                //set(strKey, pValue);
                // 避免不必要的判断，直接修改
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
                clearAllInfos(value);

                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
                value.SetString(pValue, allocator);
            } else {
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
                rapidjson::Value key(rapidjson::kStringType);
                key.SetString(strKey.c_str(), allocator);
                rapidjson::Value value(rapidjson::kStringType);
                key.SetString(pValue, allocator);
#else
                rapidjson::Value key(strKey.c_str(), allocator);
                rapidjson::Value value(pValue, allocator);
#endif
                m_spImplInstance->document.AddMember(key, value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：设置string型键值数据
 * 输入参数：
 *      strKey：键值
 *      pValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const char* pValue)
{
    if (pValue) {
        if (m_spImplInstance) {
            if (m_spImplInstance->document.HasMember(strKey.c_str())) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
                clearAllInfos(value);

                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
                value.SetString(pValue, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加string型键值数据
 * 输入参数：
 *      strKey：键值
 *      strValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const std::string &strValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, strValue);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);

            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            value.SetString(strValue.c_str(), allocator);
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kStringType);
            key.SetString(strValue.c_str(), allocator);
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(strValue.c_str(), allocator);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置string型键值数据
 * 输入参数：
 *      strKey：键值
 *      strValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const std::string &strValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);

            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            value.SetString(strValue.c_str(), allocator);
        }
    }

    return;
}

/************************************************
 * 功能：添加double型键值数据
 * 输入参数：
 *      strKey：键值
 *      dValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const double &dValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, dValue);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetDouble(dValue);
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kNumberType);
            key.SetDouble(dValue);
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(dValue);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置double型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      dValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const double &dValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetDouble(dValue);
        }
    }

    return;
}

/************************************************
 * 功能：添加int型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      iValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const int &iValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, iValue);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetInt(iValue);
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kNumberType);
            value.SetInt(iValue);
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(iValue);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置int型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      iValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const int &iValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetInt(iValue);
        }
    }

    return;
}

/************************************************
 * 功能：添加uint型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      uiValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const unsigned int &uiValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, uiValue);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetUint(uiValue);
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Value value(rapidjson::kNumberType);
            value.SetUint(uiValue);
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(uiValue);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置uint型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      uiValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const unsigned int &uiValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetUint(uiValue);
        }
    }

    return;
}

/************************************************
 * 功能：添加bool型键值数据
 * 输入参数：
 *      strKey：键值
 *      bValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const bool& bValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, bValue);
            // 避免不必要的判断，直接修改
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetBool(bValue);
        } else {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value key(rapidjson::kStringType);
            key.SetString(strKey.c_str(), allocator);
            rapidjson::Type type = bValue ? rapidjson::kTrueType : rapidjson::kFalseType;
            rapidjson::Value value(type);
            value.SetBool(bValue);
#else
            rapidjson::Value key(strKey.c_str(), allocator);
            rapidjson::Value value(bValue);
#endif
            m_spImplInstance->document.AddMember(key, value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：设置bool型键值数据
 * 输入参数：
 *      strKey：键值
 *      bValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const bool& bValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
            value.SetBool(bValue);
        }
    }

    return;
}

/************************************************
 * 功能：添加JSON型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      objValue：数据
 * ***********************************************/
void RapidJsonUtil::add(const std::string &strKey, const RapidJsonUtil &objValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, objValue);
            // 避免不必要的判断，直接修改
            if (objValue.m_spImplInstance) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
                clearAllInfos(value);

                // 深拷贝
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
                value.CopyFrom(objValue.m_spImplInstance->document, allocator);
            }
        } else {
            if (objValue.m_spImplInstance) {
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
                rapidjson::Value key(rapidjson::kStringType);
                key.SetString(strKey.c_str(), allocator);
                rapidjson::Type type = objValue.m_spImplInstance->document.IsArray() ? rapidjson::kArrayType : rapidjson::kObjectType;
                rapidjson::Value value(type);
#if 0
                // 逐一拷贝数据
                //rapidjson::Value::ConstMemberIterator iter = objValue.m_spImplInstance->document.MemberBegin();
                for (auto iter = objValue.m_spImplInstance->document.MemberBegin(); iter != objValue.m_spImplInstance->document.MemberEnd(); ++iter) {
                    rapidjson::Value jKey;
                    rapidjson::Value jValue;
                    jKey.CopyFrom(iter->name, allocator);
                    jValue.CopyFrom(iter->value, allocator);
                    value.AddMember(jKey, jValue, allocator);
                }
#else
                // 直接拷贝
                value.CopyFrom(objValue.m_spImplInstance->document, allocator);
#endif
#else
                // 深拷贝
                rapidjson::Value key(strKey.c_str(), allocator);
                rapidjson::Value value;
                value.CopyFrom(objValue.m_spImplInstance->document, allocator);
#endif
                m_spImplInstance->document.AddMember(key, value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：设置JSON型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      objValue：数据
 * ***********************************************/
void RapidJsonUtil::set(const std::string &strKey, const RapidJsonUtil &objValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            //set(strKey, objValue);
            // 避免不必要的判断，直接修改
            if (objValue.m_spImplInstance) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
                clearAllInfos(value);

                // 深拷贝
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
                value.CopyFrom(objValue.m_spImplInstance->document, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加子对象数据到当前JSON数组中
 * 输入参数：
 *      objChildValue：子对象
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const RapidJsonUtil &objChildValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            if (objChildValue.m_spImplInstance) {
                // 深拷贝
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
                rapidjson::Value value;
                value.CopyFrom(objChildValue.m_spImplInstance->document, allocator);
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加字符串数组到JSON中，例如{"arrVal":["str1", "str2", "str3"]}
 * 输入参数：
 *      pValue：字符串值
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const char* pValue)
{
    if (pValue) {
        if (m_spImplInstance) {
            if (m_spImplInstance->document.IsArray()) {
                rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
                rapidjson::Value value(rapidjson::kStringType);
                value.SetString(pValue, allocator);
#else
                rapidjson::Value value(pValue, allocator);
#endif
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加字符串数组到JSON中，例如{"arrVal":["str1", "str2", "str3"]}
 * 输入参数：
 *      strValue：字符串值
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const std::string &strValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value value(rapidjson::kStringType);
            value.SetString(strValue.c_str(), allocator);
#else
            rapidjson::Value value(strValue.c_str(), allocator);
#endif
            m_spImplInstance->document.PushBack(value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：添加int数组到JSON中，例如{"intVal":[1, 2, 3]}
 * 输入参数：
 *      iValue：int数据
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const int &iValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value value(rapidjson::kNumberType);
            value.SetInt(iValue);
#else
            rapidjson::Value value(iValue);
#endif
            m_spImplInstance->document.PushBack(value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：添加uint数组到JSON中，例如{"intVal":[1, 2, 3]}
 * 输入参数：
 *      uiValue：uint数据
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const unsigned int &uiValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value value(rapidjson::kNumberType);
            value.SetUint(uiValue);
#else
            rapidjson::Value value(uiValue);
#endif
            m_spImplInstance->document.PushBack(value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：添加double数组到JSON中，例如{"doubleVal":[1.2, 2.3, 3.4]}
 * 输入参数：
 *      dValue：double数据
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const double &dValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Value value(rapidjson::kNumberType);
            value.SetDouble(dValue);
#else
            rapidjson::Value value(dValue);
#endif
            m_spImplInstance->document.PushBack(value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：添加bool数组到JSON中，例如{"boolVal":[true, false, true]}
 * 输入参数：
 *      bValue：bool数据
 * ***********************************************/
void RapidJsonUtil::addDataToArray(const bool& bValue)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
#if CONSTRUCT_MODE_ONE
            rapidjson::Type type = bValue ? rapidjson::kTrueType : rapidjson::kFalseType;
            rapidjson::Value value(type);
            value.SetBool(bValue);
#else
            rapidjson::Value value(bValue);
#endif
            m_spImplInstance->document.PushBack(value, allocator);
        }
    }

    return;
}

/************************************************
 * 功能：删除某对key-value
 * 输入参数：
 *      strKey：待删除的key
 * ***********************************************/
void RapidJsonUtil::deleteKey(const std::string &strKey)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.HasMember(strKey.c_str())) {
            rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()];
            clearAllInfos(value);
#if CONSTRUCT_MODE_ONE
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            rapidjson::Value key(strKey.c_str(), allocator);
            m_spImplInstance->document.RemoveMember(key);
#else
            m_spImplInstance->document.RemoveMember(strKey.c_str());
#endif
        }
    }
    return;
}

/************************************************
 * 功能：数据转换为字符串值
 * 返回值：
 *      std::string：转换后的数据
 * ***********************************************/
std::string RapidJsonUtil::toString() const
{
    std::string strRet = "";
    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.IsString()) {
            strRet = m_spImplInstance->document.GetString();
        }
    }
    return strRet;
}

/************************************************
 * 功能：数据转换为bool
 * 返回值：
 *      bool：转换后的数据
 * ***********************************************/
bool RapidJsonUtil::toBool() const
{
    bool bRet = false;
    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.IsBool()) {
            bRet = m_spImplInstance->document.GetBool();
        }
    }
    return bRet;
}

/************************************************
 * 功能：数据转换为int
 * 返回值：
 *      int：转换后的数据
 * ***********************************************/
int RapidJsonUtil::toInt() const
{
    int iRet = 0;
    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.IsInt()) {
            iRet = m_spImplInstance->document.GetInt();
        }
    }
    return iRet;
}

/************************************************
 * 功能：数据转换为unsigned int
 * 返回值：
 *      unsigned int：转换后的数据
 * ***********************************************/
unsigned int RapidJsonUtil::toUInt() const
{
    unsigned int uiRet = 0;
    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.IsUint()) {
            uiRet = m_spImplInstance->document.GetUint();
        }
    }
    return uiRet;
}

/************************************************
 * 功能：数据转换为double
 * 返回值：
 *      double：转换后的数据
 * ***********************************************/
double RapidJsonUtil::toDouble() const
{
    double dRet = 0;
    if (m_spImplInstance && m_bOk) {
        if (m_spImplInstance->document.IsDouble()) {
            dRet = m_spImplInstance->document.GetDouble();
        }
    }
    return dRet;
}

/************************************************
 * 功能：根据key获取string数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      std::string：获得的数据
 * ***********************************************/
std::string RapidJsonUtil::getString(const std::string& strKey)
{
    std::string strRet = "";
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsString()) {
            strRet = m_spImplInstance->document[strKey.c_str()].GetString();
        } else if (m_spImplInstance->document[strKey.c_str()].IsObject()
                   || m_spImplInstance->document[strKey.c_str()].IsArray()) {
            strRet = getUnformatJsonString(m_spImplInstance->document);
        } else {
            // TODO
        }
    }
    return strRet;
}

/************************************************
 * 功能：根据key获取int数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      int：获得的数据
 * ***********************************************/
int RapidJsonUtil::getInt(const std::string& strKey)
{
    int iRet = 0;
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsInt()) {
            iRet = m_spImplInstance->document[strKey.c_str()].GetInt();
        }
    }
    return iRet;
}

/************************************************
 * 功能：根据key获取uint数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      uint：获得的数据
 * ***********************************************/
unsigned int RapidJsonUtil::getUInt(const std::string& strKey)
{
    unsigned int uiRet = 0;
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsUint()) {
            uiRet = m_spImplInstance->document[strKey.c_str()].GetUint();
        }
    }
    return uiRet;
}

/************************************************
 * 功能：根据key获取double数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      double：获得的数据
 * ***********************************************/
double RapidJsonUtil::getDouble(const std::string& strKey)
{
    double dRet = 0;
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsDouble()) {
            dRet = m_spImplInstance->document[strKey.c_str()].GetDouble();
        }
    }
    return dRet;
}

/************************************************
 * 功能：根据key获取bool数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      bool：获得的数据
 * ***********************************************/
bool RapidJsonUtil::getBool(const std::string& strKey)
{
    bool bRet = false;
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsBool()) {
            bRet = m_spImplInstance->document[strKey.c_str()].GetBool();
        }
    }
    return bRet;
}

/************************************************
 * 功能：添加string数组数据，包括object、Array等
 * 输入参数：
 *      vtValues：待添加的数据集合
 *      eType：当待添加的数据为object、Array时，需要填写
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<std::string> &vtValues, Type eType)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                if (RapidJsonUtil::NA == eType) {
                    rapidjson::Value value(vtValues[i].c_str(), allocator);
                    m_spImplInstance->document.PushBack(value, allocator);
                } else {
                    rapidjson::Document doc;
                    doc.Parse(vtValues[i].c_str());
                    if (!doc.HasParseError()) {
                        // 深拷贝
                        rapidjson::Value value;
                        value.CopyFrom(doc, allocator);
                        m_spImplInstance->document.PushBack(value, allocator);
                    }
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加int数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<int> &vtValues)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                rapidjson::Value value(vtValues[i]);
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加uint数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<unsigned int> &vtValues)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                rapidjson::Value value(vtValues[i]);
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加double数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<double> &vtValues)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                rapidjson::Value value(vtValues[i]);
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加bool数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<bool> &vtValues)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                rapidjson::Value value(vtValues[i]);
                m_spImplInstance->document.PushBack(value, allocator);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加object数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addArray(const std::vector<RapidJsonUtil> &vtValues)
{
    if (m_spImplInstance) {
        if (m_spImplInstance->document.IsArray()) {
            rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
            for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
                if (vtValues[i].m_spImplInstance) {
                    // 深拷贝
                    rapidjson::Value value;
                    value.CopyFrom(vtValues[i].m_spImplInstance->document, allocator);
                    m_spImplInstance->document.PushBack(value, allocator);
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加string数组数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 *      eType：当待添加的数据为object、Array时，需要填写
 * ***********************************************/
void RapidJsonUtil::addStringArray(const std::string& strKey, const std::vector<std::string> &vtValues, Type eType)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            if (RapidJsonUtil::NA == eType) {
                rapidjson::Value v(vtValues[i].c_str(), allocator);
                value.PushBack(v, allocator);
            } else {
                rapidjson::Document doc;
                doc.Parse(vtValues[i].c_str());
                if (!doc.HasParseError()) {
                    // 深拷贝
                    rapidjson::Value v;
                    v.CopyFrom(doc, allocator);
                    value.PushBack(v, allocator);
                }
            }
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key添加int数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addIntArray(const std::string& strKey, const std::vector<int> &vtValues)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            value.PushBack(vtValues[i], allocator);
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key添加uint数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addUIntArray(const std::string& strKey, const std::vector<unsigned int> &vtValues)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            value.PushBack(vtValues[i], allocator);
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key添加double数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addDoubleArray(const std::string& strKey, const std::vector<double> &vtValues)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            value.PushBack(vtValues[i], allocator);
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key添加bool数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addBoolArray(const std::string& strKey, const std::vector<bool> &vtValues)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            value.PushBack(vtValues[i], allocator);
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key添加object数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void RapidJsonUtil::addObjArray(const std::string& strKey, const std::vector<RapidJsonUtil> &vtValues)
{
    if (m_spImplInstance) {
        rapidjson::Document::AllocatorType& allocator = m_spImplInstance->document.GetAllocator();
        rapidjson::Value key(strKey.c_str(), allocator);
        rapidjson::Value value(rapidjson::kArrayType);
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            if (vtValues[i].m_spImplInstance) {
                // 深拷贝
                rapidjson::Value v;
                v.CopyFrom(vtValues[i].m_spImplInstance->document, allocator);
                value.PushBack(v, allocator);
            }
        }
        m_spImplInstance->document.AddMember(key, value, allocator);
    }

    return;
}

/************************************************
 * 功能：根据key获取string数组数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getStringArray(const std::string& strKey, std::vector<std::string> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                if (value.IsString()) {
                    vtValues.emplace_back(value.GetString());
                } else if (value.IsObject() || value.IsArray()) {
                    vtValues.emplace_back(getUnformatJsonString(value));
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取int数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getIntArray(const std::string& strKey, std::vector<int> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                if (value.IsInt()) {
                    vtValues.emplace_back(value.GetInt());
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取uint数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getUIntArray(const std::string& strKey, std::vector<unsigned int> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                if (value.IsUint()) {
                    vtValues.emplace_back(value.GetUint());
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取double数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getDoubleArray(const std::string& strKey, std::vector<double> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                if (value.IsDouble()) {
                    vtValues.emplace_back(value.GetDouble());
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取bool数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getBoolArray(const std::string& strKey, std::vector<bool> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                if (value.IsBool()) {
                    vtValues.emplace_back(value.GetBool());
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取object数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void RapidJsonUtil::getObjArray(const std::string& strKey, std::vector<RapidJsonUtil> &vtValues)
{
    if (m_spImplInstance && m_spImplInstance->document.HasMember(strKey.c_str())) {
        if (m_spImplInstance->document[strKey.c_str()].IsArray()) {
            for (size_t i = 0, size = m_spImplInstance->document[strKey.c_str()].Size();
                 i < size; ++i) {
                rapidjson::Value& value = m_spImplInstance->document[strKey.c_str()][i];
                RapidJsonUtil::Type type = value.IsArray() ? RapidJsonUtil::Array : RapidJsonUtil::Object;
                RapidJsonUtil objUtil(type);
                if (objUtil.m_spImplInstance) {
                    // 深拷贝
                    rapidjson::Document::AllocatorType& allocator = objUtil.m_spImplInstance->document.GetAllocator();
                    objUtil.m_spImplInstance->document.CopyFrom(value, allocator);
                    vtValues.emplace_back(objUtil);
                }
            }
        }
    }

    return;
}
